<!DOCTYPE html>
<html>

  <head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">

  <title>安卓自定义View进阶-Matrix原理</title>
  <meta name="description" content="Matrix原理，详细讲解Matrix原理，了解Matrix各个部分的作用，以及set、pre与post的区别。">
  <meta name="author" content="GcsSloop">
  <meta name="keywords" content="Matrix, Matrix原理, Matrix详解, pre与post的区别, 自定义View详解, 自定义控件, 安卓, Android, CustomView, GcsSloop">
  <meta name="关键字" content="Matrix, Matrix原理, Matrix详解, pre与post的区别, 自定义View详解, 自定义控件, 安卓, Android, CustomView, GcsSloop">
  

  <meta name="twitter:card" content="summary">
  <meta name="twitter:title" content="安卓自定义View进阶-Matrix原理">
  <meta name="twitter:description" content="Matrix原理，详细讲解Matrix原理，了解Matrix各个部分的作用，以及set、pre与post的区别。">
  <meta name="twitter:keywords" content="Matrix, Matrix原理, Matrix详解, pre与post的区别, 自定义View详解, 自定义控件, 安卓, Android, CustomView, GcsSloop">
  
  <meta property="og:type" content="article">
  <meta property="og:title" content="安卓自定义View进阶-Matrix原理">
  <meta property="og:description" content="Matrix原理，详细讲解Matrix原理，了解Matrix各个部分的作用，以及set、pre与post的区别。">
  <meta name="og:keywords" content="Matrix, Matrix原理, Matrix详解, pre与post的区别, 自定义View详解, 自定义控件, 安卓, Android, CustomView, GcsSloop">

  <meta name="theme-color" content="#343434">
  
  <link rel="icon" type="image/png" href="https://raw.githubusercontent.com/GcsSloop/gcssloop.github.io/master/assets/siteinfo/favicon.png" />
  <link href="https://raw.githubusercontent.com/GcsSloop/gcssloop.github.io/master/assets/siteinfo/favicon.png" rel="shortcut icon" type="image/png">
  
  <link href="//netdna.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css" rel="stylesheet">
  <link rel="stylesheet" href="/css/main.css">

  <link rel="canonical" href="http://www.gcssloop.com/customview/Matrix_Basic">
  <link rel="alternate" type="application/rss+xml" title="GcsSloop" href="http://www.gcssloop.com/feed.xml">
  
  <meta name="google-site-verification" content="Z_g58PkzRAyBMxkqrcDdWrTBK8oOWM-7rUHauhLNF2E" />
  <meta name="baidu-site-verification" content="kUtTXCKaZs" />
  <meta name="baidu-site-verification" content="6DuDv3aaJX" />
  
  <!--阅读次数统计-->
  <script async src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"> </script>
  
  <!--Fuck Weixin and Baidu-->
  <meta http-equiv="Cache-Control" content="no-transform">
  <meta http-equiv=”Cache-Control” content=”no-siteapp” />
  <meta name="applicable-device" content="pc,mobile">
  <meta name="HandheldFriendly" content="true"/>

  <!-- Google Ad -->
  <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
  <script>
    (adsbygoogle = window.adsbygoogle || []).push({
      google_ad_client: "ca-pub-2767831356529421",
      enable_page_level_ads: true
    });
  </script>

</head>


  <body>

    <span class="mobile btn-mobile-menu">
        <i class="fa fa-list btn-mobile-menu__icon"></i>
        <i class="fa fa-angle-up btn-mobile-close__icon hidden"></i>
    </span>
    
    <header class="panel-cover panel-cover--collapsed" style="background-image: url('/assets/siteinfo/background-cover.jpg')">
  <div class="panel-main">

    <div class="panel-main__inner panel-inverted">
    <div class="panel-main__content">

        <a href="/#blog" title="前往 GcsSloop 的主页" class="blog-button"><img src="/assets/siteinfo/avatar.jpg" width="80" alt="GcsSloop logo" class="panel-cover__logo logo" /></a>
        <h1 class="panel-cover__title panel-title"><a href="/#blog" title="link to homepage for GcsSloop" class="blog-button">GcsSloop</a></h1>

        
        <span class="panel-cover__subtitle panel-subtitle">Just do IT later.</span>
        
        <hr class="panel-cover__divider" />
        <p class="panel-cover__description">嗨，我是 GcsSloop，一名来自2.5次元的魔法师，Android自定义View系列文章作者，非著名程序员。</p>
        <hr class="panel-cover__divider panel-cover__divider--secondary" />
        
        
        <p class="panel-cover__description">欢迎来到我的魔法世界!</p>
        
        
        <div class="navigation-wrapper">
          <div>
            <nav class="cover-navigation cover-navigation--primary">
              <ul class="navigation">
                <li class="navigation__item"><a href="/#blog" title="访问博客" class="blog-button">博客</a></li>
                
                  
                    <li class="navigation__item"><a href="https://github.com/GcsSloop" target="_blank" title="GcsSloop's GitHub">GitHub</a></li>
                  
                  
                
                  
                    <li class="navigation__item"><a href="/timeline" title="博客目录">目录</a></li>
                  
                  
                
                  
                    <li class="navigation__item"><a href="https://xiaozhuanlan.com/u/GcsSloop" target="_blank" title="小专栏">专栏</a></li>
                  
                  
                
                  
                    <li class="navigation__item"><a href="/category/customview" title="自定义View教程目录">自定义控件</a></li>
                  
                  
                
                  
                    <li class="navigation__item"><a href="/friends" title="友链">友链</a></li>
                  
                  
                
              </ul>
            </nav>
          </div>
          
          <div><nav class="cover-navigation navigation--social">
  <ul class="navigation">

  
  <!-- Weibo -->
  <li class="navigation__item">
    <a href="http://weibo.com/GcsSloop" title="@GcsSloop 的微博" target="_blank">
      <i class='social fa fa-weibo'></i>
      <span class="label">Weibo</span>
    </a>
  </li>
  

  
  <!-- Github -->
  <li class="navigation__item">
    <a href="https://github.com/GcsSloop" title="@GcsSloop 的 Github" target="_blank">
      <i class='social fa fa-github'></i>
      <span class="label">Github</span>
    </a>
  </li>
  
  
  
  <!-- Twitter -->
  <li class="navigation__item">
    <a href="http://twitter.com/GcsSloop" title="@GcsSloop" target="_blank">
      <i class='social fa fa-twitter'></i>
      <span class="label">Twitter</span>
    </a>
  </li>
  

    

  

  
  <!-- RSS -->
  <li class="navigation__item">
    <a href="/feed.xml" rel="author" title="RSS" target="_blank">
      <i class='social fa fa-rss'></i>
      <span class="label">RSS</span>
    </a>
  </li>
  

  
  <!-- Email -->
  <li class="navigation__item">
    <a href="mailto:GcsSloop@gmail.com" title="发邮件给我">
      <i class='social fa fa-envelope'></i>
      <span class="label">Email</span>
    </a>
  </li>
  

  
  <!-- Copyright -->
  <li class="navigation__item">
    <a href="http://choosealicense.online" title="选择版权"  target="_blank">
      <i class="social fa fa-copyright"></i>
      <span class="label">版权</span>
    </a>
  </li>
  
  
  </ul>
</nav>
</div>
        </div>
      </div>
    </div>
    
    
    <div class="panel-cover--overlay cover-slate"></div>
    
  </div>
</header>


    <div class="content-wrapper">
        <div class="content-wrapper__inner">
            <article class="post-container post-container--single" itemscope itemtype="http://schema.org/BlogPosting">
  <header class="post-header">
    <div class="post-meta" style="font-size:.8em">
      <time datetime="2016-08-03 00:00:00 +0800" itemprop="datePublished" class="post-meta__date date">2016-08-03</time> &#8226; <span class="post-meta__tags tags">自定义View,Matrix</span> &#8226; View <span id="busuanzi_value_page_pv"></span> times.
</span>
    </div>
    <h1 class="post-title">安卓自定义View进阶-Matrix原理</h1>
  </header>

  <section class="post">
    <p>本文内容偏向理论，和 <a href="http://www.gcssloop.com/customview/Canvas_Convert">画布操作</a> 有重叠的部分，本文会让你更加深入的了解其中的原理。</p>

<p>本篇的主角Matrix，是一个一直在后台默默工作的劳动模范，虽然我们所有看到View背后都有着Matrix的功劳，但我们却很少见到它，本篇我们就看看它是何方神圣吧。</p>

<blockquote>
  <p>由于Google已经对这一部分已经做了很好的封装，所以跳过本部分对实际开发影响并不会太大，不想深究的粗略浏览即可，下一篇中将会详细讲解Matrix的具体用法和技巧。</p>

  <h2 id="️-警告测试本文章示例之前请关闭硬件加速">⚠️ 警告：测试本文章示例之前请关闭硬件加速。</h2>
</blockquote>

<h2 id="matrix简介">Matrix简介</h2>

<p><strong>Matrix是一个矩阵，主要功能是坐标映射，数值转换。</strong></p>

<p>它看起来大概是下面这样:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
MSCALE\_X &amp; MSKEW\_X &amp; MTRANS\_X \
\
MSKEW\_Y &amp; MSCALE\_Y &amp; MTRANS\_Y \
\
MPERSP\_0 &amp; MPERSP\_1 &amp; MPERSP\_2 
\end{1} 
\right ] 
$$" alt="" /></p>

<p><strong>Matrix作用就是坐标映射，那么为什么需要Matrix呢? 举一个简单的例子:</strong></p>

<p>我的的手机屏幕作为物理设备，其物理坐标系是从左上角开始的，但我们在开发的时候通常不会使用这一坐标系，而是使用内容区的坐标系。</p>

<p>以下图为例，我们的内容区和屏幕坐标系还相差一个通知栏加一个标题栏的距离，所以两者是不重合的，我们在内容区的坐标系中的内容最终绘制的时候肯定要转换为实际的物理坐标系来绘制，Matrix在此处的作用就是转换这些数值。</p>

<blockquote>

  <p>假设通知栏高度为20像素，导航栏高度为40像素,那么我们在内容区的(0，0)位置绘制一个点，最终就要转化为在实际坐标系中的(0，60)位置绘制一个点。</p>
</blockquote>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071728.jpg?gcssloop" alt="" /></p>

<p>以上是仅作为一个简单的示例，实际上不论2D还是3D，我们要将图形显示在屏幕上，都离不开Matrix，所以说Matrix是一个在背后辛勤工作的劳模。</p>

<h3 id="matrix特点">Matrix特点</h3>

<ul>
  <li>
    <p>作用范围更广，Matrix在View，图片，动画效果等各个方面均有运用，相比与之前讲解等画布操作应用范围更广。</p>
  </li>
  <li>
    <p>更加灵活，画布操作是对Matrix的封装，Matrix作为更接近底层的东西，必然要比画布操作更加灵活。</p>
  </li>
  <li>
    <p>封装很好，Matrix本身对各个方法就做了很好的封装，让开发者可以很方便的操作Matrix。</p>
  </li>
  <li>
    <p>难以深入理解，很难理解中各个数值的意义，以及操作规律，如果不了解矩阵，也很难理解前乘，后乘。</p>
  </li>
</ul>

<h3 id="常见误解">常见误解</h3>

<p><strong>1.认为Matrix最下面的一行的三个参数(MPERSP_0、MPERSP_1、MPERSP_2)没有什么太大的作用，在这里只是为了凑数。</strong></p>

<p>实际上最后一行参数在3D变换中有着至关重要的作用，这一点会在后面中Camera一文中详细介绍。</p>

<p><strong>2.最后一个参数MPERSP_2被解释为scale</strong></p>

<p>的确，更改MPERSP_2的值能够达到类似缩放的效果，但这是因为齐次坐标的缘故，并非这个参数的实际功能。</p>

<h2 id="matrix基本原理">Matrix基本原理</h2>

<p>Matrix 是一个矩阵，最根本的作用就是坐标转换，下面我们就看看几种常见变换的原理:</p>

<blockquote>
  <p>我们所用到的变换均属于仿射变换，仿射变换是 线性变换(缩放，旋转，错切) 和 平移变换(平移) 的复合，由于这些概念对于我们作用并不大，此处不过多介绍，有兴趣可自行了解。</p>
</blockquote>

<p>基本变换有4种: 平移(translate)、缩放(scale)、旋转(rotate) 和 错切(skew)。</p>

<p>下面我们看一下四种变换都是由哪些参数控制的。</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071730.jpg?gcssloop" alt="" />
<img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071731.jpg?gcssloop" alt="" /></p>

<p><strong>从上图可以看到最后三个参数是控制透视的，这三个参数主要在3D效果中运用，通常为(0, 0, 1)，不在本篇讨论范围内，暂不过多叙述，会在之后对文章中详述其作用。</strong></p>

<p>由于我们以下大部分的计算都是基于矩阵乘法规则，如果你已经把线性代数还给了老师，请参考一下这里:
<strong><a href="https://zh.wikipedia.org/wiki/%E7%9F%A9%E9%99%A3%E4%B9%98%E6%B3%95">维基百科-矩阵乘法</a></strong></p>

<h3 id="1缩放scale">1.缩放(Scale)</h3>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071733.png?gcssloop" alt="" /></p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071736.png?gcssloop" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix} 
k_1  &amp;   0   &amp;  0  \\
 0   &amp;  k_2  &amp;  0  \\
 0   &amp;   0   &amp;  1
\end{1} 
\right ] 
\left [ 
\begin{matrix} 
x_0 \\
y_0 \\
1
\end{1} 
\right ]
$$" alt="" /></p>

<blockquote>

  <p>你可能注意到了，我们坐标多了一个1，这是使用了齐次坐标系的缘故，在数学中我们的点和向量都是这样表示的(x, y)，两者看起来一样，计算机无法区分，为此让计算机也可以区分它们，增加了一个标志位，增加之后看起来是这样: <br /></p>

  <p>(x, y, 1) - 点<br />
(x, y, 0) - 向量<br /></p>

  <p>另外，齐次坐标具有等比的性质，(2,3,1)、(4,6,2)…(2N,3N,N)表示的均是(2,3)这一个点。(<strong>将MPERSP_2解释为scale这一误解就源于此</strong>)。</p>
</blockquote>

<p>图例：</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071736.jpg?gcssloop" alt="" /></p>

<h3 id="2错切skew">2.错切(Skew)</h3>

<p>错切存在两种特殊错切，水平错切(平行X轴)和垂直错切(平行Y轴)。</p>

<h4 id="水平错切">水平错切</h4>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071738.png?gcssloop" alt="" /></p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071739.png?gcssloop" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix}  
 1   &amp;  k  &amp;  0 \\
 0   &amp;  1   &amp;  0 \\
 0   &amp;  0   &amp;  1
\end{1} 
\right ] 
\left [ 
\begin{matrix} 
x_0\\
y_0\\
1
\end{1} 
\right ]
$$" alt="" /></p>

<p>图例:</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071740.jpg?gcssloop" alt="" /></p>

<h4 id="垂直错切">垂直错切</h4>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071744.png?gcssloop" alt="" /></p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071745.png?gcssloop" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix}  
 1   &amp;  0  &amp;  0 \\
 k   &amp;  1   &amp;  0 \\
 0   &amp;  0   &amp;  1
\end{1} 
\right ] 
\left [ 
\begin{matrix} 
x_0\\
y_0\\
1
\end{1} 
\right ]
$$" alt="" /></p>

<p>图例:</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071745.jpg?gcssloop" alt="" /></p>

<h4 id="复合错切">复合错切</h4>

<blockquote>
  <p>水平错切和垂直错切的复合。</p>
</blockquote>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071747.png?gcssloop" alt="" /></p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071748.png?gcssloop" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix}  
 1   &amp;  k_1 &amp;  0 \\
 k_2 &amp;  1   &amp;  0 \\
 0   &amp;  0   &amp;  1
\end{1} 
\right ] 
\left [ 
\begin{matrix} 
x_0\\
y_0\\
1
\end{1} 
\right ]
$$" alt="" /></p>

<p>图例:</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-71752.jpg?gcssloop" alt="" /></p>

<h3 id="3旋转rotate">3.旋转(Rotate)</h3>

<p>假定一个点 A(x<sub>0</sub>, y<sub>0</sub>) ,距离原点距离为 r, 与水平轴夹角为 α 度, 绕原点旋转 θ 度, 旋转后为点 B(x, y) 如下:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$ x_0 = r \cdot cos \alpha $$" alt="" /></p>

<p><img src="http://latex.codecogs.com/png.latex?$$ y_0 = r \cdot sin \alpha $$" alt="" /></p>

<p><img src="http://latex.codecogs.com/png.latex?$$
x = r \cdot cos( \alpha + \theta) 
= r \cdot cos \alpha \cdot cos \theta - r \cdot sin \alpha \cdot sin \theta 
= x_0 \cdot cos \theta - y_0 \cdot sin \theta
$$" alt="" /></p>

<p><img src="http://latex.codecogs.com/png.latex?$$
y = r \cdot sin( \alpha + \theta) 
= r \cdot sin \alpha \cdot cos \theta + r \cdot cos \alpha \cdot sin \theta 
= y_0 \cdot cos \theta + x_0 \cdot sin \theta
$$" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix} 
cos(\theta) &amp; -sin(\theta) &amp;  0 \\
sin(\theta) &amp; cos(\theta)  &amp;  0 \\
0                &amp;       0              &amp;  1
\end{1} 
\right ] 
 . 
\left [ 
\begin{matrix} 
x_0\\
y_0\\
1
\end{1} 
\right ]
$$" alt="" /></p>

<p>图例:</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071753.jpg?gcssloop" alt="" /></p>

<h3 id="4平移translate">4.平移(Translate)</h3>

<blockquote>

  <p>此处也是使用齐次坐标的优点体现之一，实际上前面的三个操作使用 2x2 的矩阵也能满足需求，但是使用 2x2 的矩阵，无法将平移操作加入其中，而将坐标扩展为齐次坐标后，将矩阵扩展为 3x3 就可以将算法统一，四种算法均可以使用矩阵乘法完成。</p>
</blockquote>

<p><img src="http://latex.codecogs.com/png.latex?$$ x = x_0 + \Delta x $$" alt="" /></p>

<p><img src="http://latex.codecogs.com/png.latex?$$ y = y_0 + \Delta y $$" alt="" /></p>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
x\\
y\\
1
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix} 
1 &amp; 0 &amp; \Delta x \\
0 &amp; 1 &amp; \Delta y \\
0 &amp; 0 &amp; 1
\end{1} 
\right ] 
 . 
\left [ 
\begin{matrix} 
x_0\\
y_0\\
1
\end{1} 
\right ]
$$" alt="" /></p>

<p>图例:</p>

<p><img src="http://gcsblog.oss-cn-shanghai.aliyuncs.com/blog/2019-04-29-071754.jpg?gcssloop" alt="" /></p>

<h2 id="matrix复合原理">Matrix复合原理</h2>

<p>其实Matrix的多种复合操作都是使用矩阵乘法实现的，从原理上理解很简单，但是，使用矩阵乘法也有其弱点，后面的操作可能会影响到前面到操作，所以在构造Matrix时顺序很重要。</p>

<p>我们常用的四大变换操作，每一种操作在Matrix均有三类,前乘(pre)，后乘(post)和设置(set)，可以参见文末对<a href="#fangfa">Matrix方法表</a>，由于矩阵乘法不满足交换律，所以前乘(pre)，后乘(post)和设置(set)的区别还是很大的。</p>

<h3 id="前乘pre">前乘(pre)</h3>

<p>前乘相当于矩阵的右乘：</p>

<p><img src="http://latex.codecogs.com/png.latex?$$ M' =  M \cdot S $$" alt="" /></p>

<blockquote>
  <p>这表示一个矩阵与一个特殊矩阵前乘后构造出结果矩阵。</p>
</blockquote>

<h3 id="后乘post">后乘(post)</h3>

<p>后乘相当于矩阵的左乘：</p>

<p><img src="http://latex.codecogs.com/png.latex?$$ M' =  S \cdot M $$" alt="" /></p>

<blockquote>
  <p>这表示一个矩阵与一个特殊矩阵后乘后构造出结果矩阵。</p>
</blockquote>

<h3 id="设置set">设置(set)</h3>

<p>设置使用的不是矩阵乘法，而是直接覆盖掉原来的数值，所以，<strong>使用设置可能会导致之前的操作失效</strong>。</p>

<h2 id="组合">组合</h2>

<p><strong>关于 Matrix 的文章终有一个问题，就是 pre 和 post 这一部分的理论非常别扭，国内大多数文章都是这样的，看起来貌似是对的但很难理解，部分内容违背直觉。</strong></p>

<p><strong>我由于也受到了这些文章的影响，自然而然的继承了这一理论，直到在评论区有一位小伙伴提出了一个问题，才让我重新审视了这一部分的内容，并进行了一定反思。</strong></p>

<p>经过良久的思考之后，我决定抛弃国内大部分文章的那套理论和结论，只用严谨的数学逻辑和程序逻辑来阐述这一部分的理论，也许仍有疏漏，如有发现请指正。</p>

<p><strong>首先澄清两个错误结论，记住，是错误结论，错误结论，错误结论。</strong></p>

<h3 id="错误结论一pre-是顺序执行post-是逆序执行"><del>错误结论一：pre 是顺序执行，post 是逆序执行。</del></h3>

<p>这个结论很具有迷惑性，因为这个结论并非是完全错误的，你很容易就能证明这个结论，例如下面这样：</p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">// 第一段 pre  顺序执行，先平移(T)后旋转(R)</span>
<span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preRotate</span><span class="o">(</span><span class="n">angle</span><span class="o">);</span>
<span class="n">Log</span><span class="o">.</span><span class="na">e</span><span class="o">(</span><span class="s">"Matrix"</span><span class="o">,</span> <span class="n">matrix</span><span class="o">.</span><span class="na">toShortString</span><span class="o">());</span>

<span class="c1">// 第二段 post 逆序执行，先平移(T)后旋转(R)</span>
<span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">postRotate</span><span class="o">(</span><span class="n">angle</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">)</span>
<span class="n">Log</span><span class="o">.</span><span class="na">e</span><span class="o">(</span><span class="s">"Matrix"</span><span class="o">,</span> <span class="n">matrix</span><span class="o">.</span><span class="na">toShortString</span><span class="o">());</span>
</code></pre>
</div>

<p><strong>这两段代码最终结果是等价的，于是轻松证得这个结论的正确性，但事实真是这样么？</strong></p>

<p>首先，从数学角度分析，pre 和 post 就是右乘或者左乘的区别，其次，它们不可能实际影响运算顺序(程序执行顺序)。以上这两段代码等价也仅仅是因为最终化简公式一样而已。</p>

<blockquote>
  <p>设原始矩阵为 M，平移为 T ，旋转为 R ，单位矩阵为 I ，最终结果为 M’</p>

  <ul>
    <li>矩阵乘法不满足交换律，即 A*B ≠ B*A</li>
    <li>矩阵乘法满足结合律，即 (A*B)*C = A*(B*C)</li>
    <li>矩阵与单位矩阵相乘结果不变，即 A * I = A</li>
  </ul>
</blockquote>

<div class="highlighter-rouge"><pre class="highlight"><code>由于上面例子中原始矩阵(M)是一个单位矩阵(I)，所以可得：

// 第一段 pre
M' = (M*T)*R = I*T*R = T*R

// 第二段 post
M' = T*(R*M) = T*R*I = T*R
</code></pre>
</div>

<p>由于两者最终的化简公式是相同的，所以两者是等价的，但是，这结论不具备普适性。</p>

<p><strong>即原始矩阵不为单位矩阵的时候，两者无法化简为相同的公式，结果自然也会不同。另外，执行顺序就是程序书写顺序，不存在所谓的正序逆序。</strong></p>

<h3 id="错误结论二pre-是先执行而-post-是后执行"><del>错误结论二：pre 是先执行，而 post 是后执行。</del></h3>

<p>这一条结论比上一条更离谱。</p>

<p>之所以产生这个错误完全是因为写文章的人懂英语。</p>

<div class="highlighter-rouge"><pre class="highlight"><code>pre  ：先，和 before 相似。
post ：后，和 after  相似。
</code></pre>
</div>

<p>所以就得出了 pre 先执行，而 post 后执行这一说法，但从严谨的数学和程序角度来分析，完全是不可能的，还是上面所说的，<strong>pre 和 post 不能影响程序执行顺序，而程序每执行一条语句都会得出一个确定的结果，所以，它根本不能控制先后执行，属于完全扯淡型。</strong></p>

<p><strong>如果非要用这套理论强行解释的话，反而看起来像是 post 先执行，例如：</strong></p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">matrix</span><span class="o">.</span><span class="na">preRotate</span><span class="o">(</span><span class="n">angle</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">);</span>
</code></pre>
</div>

<p>同样化简公式：</p>

<div class="highlighter-rouge"><pre class="highlight"><code>// 矩阵乘法满足结合律
M‘ = T*(M*R) = T*M*R = (T*M)*R
</code></pre>
</div>

<p><strong>从实际上来说，由于矩阵乘法满足结合律，所以不论你说是靠右先执行还是靠左先执行，从结果上来说都没有错。</strong></p>

<p><strong>之前基于这条错误的结论我进行了一次错误的证明：</strong></p>

<blockquote>
  <p><strong>(这段内容注定要成为我写作历程中不可抹灭的耻辱，既然是公开文章，就应该对读者负责，虽然我在发表每一篇文章之前都竭力的求证其中的问题，各种细节，避免出现这种错误，但终究还是留下了这样一段内容，在此我诚挚的向我所有的读者道歉。)</strong></p>

  <p>关注我的读者请尽量看我在 <a href="http://www.gcssloop.com/#blog">个人博客</a> 和 <a href="https://github.com/GcsSloop/AndroidNote/blob/master/README.md">GitHub</a> 发布的版本，这两个平台都在博文修复计划之内，有任何错误或者纰漏，都会首先修复这两个平台的文章。另外，所有进行修复过的文章都会在我的微博 <a href="http://weibo.com/GcsSloop">@GcsSloop</a> 重新发布说明，关注我的微博可以第一时间得到博文更新或者修复的消息。</p>

  <hr />

  <h2 id="以下是错误证明">以下是错误证明：</h2>

  <p><del>在实际操作中，我们每一步操作都会得出准确的计算结果，但是为什么还会用存在先后的说法? 难道真的能够用pre和post影响计算顺序? 实则不然，下面我们用一个例子说明:</del></p>

  <div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">postScale</span><span class="o">(</span><span class="mf">0.5f</span><span class="o">,</span> <span class="mf">0.8f</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="mi">1000</span><span class="o">,</span> <span class="mi">1000</span><span class="o">);</span>
<span class="n">Log</span><span class="o">.</span><span class="na">e</span><span class="o">(</span><span class="n">TAG</span><span class="o">,</span> <span class="s">"MatrixTest"</span> <span class="o">+</span> <span class="n">matrix</span><span class="o">.</span><span class="na">toShortString</span><span class="o">());</span>
</code></pre>
  </div>

  <p><del>在上面的操作中，如果按照正常的思路，先缩放，后平移，缩放操作执行在前，不会影响到后续的平移操作，但是执行结果却发现平移距离变成了(500， 800)。</del></p>

  <p><del>在上面例子中，计算顺序是没有问题的，先计算的缩放，然后计算的平移，而缩放影响到平移则是因为前一步缩放后的结果矩阵右乘了平移矩阵，这是符合矩阵乘法的运算规律的，也就是说缩放操作虽然在前却影响到了平移操作，<strong>相当于先执行了平移操作，然后执行的缩放操作，因此才有pre操作会先执行，而post操作会后执行这一说法</strong>。</del></p>

  <hr />

  <p>上面的论证是完全错误的，因为可以轻松举出反例：</p>

  <div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preScale</span><span class="o">(</span><span class="mf">0.5f</span><span class="o">,</span> <span class="mf">0.8f</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="mi">1000</span><span class="o">,</span> <span class="mi">1000</span><span class="o">);</span>
<span class="n">Log</span><span class="o">.</span><span class="na">e</span><span class="o">(</span><span class="n">TAG</span><span class="o">,</span> <span class="s">"MatrixTest"</span> <span class="o">+</span> <span class="n">matrix</span><span class="o">.</span><span class="na">toShortString</span><span class="o">());</span>
</code></pre>
  </div>

  <p>反例中，虽然将 <code class="highlighter-rouge">postScale</code> 改为了 <code class="highlighter-rouge">preScale</code> ，但两者结果是完全相同的，所以先后论根本就是错误的。</p>

  <p>他们结果相同是因为最终化简公式是相同的，都是 S*T</p>

  <p>之所以平移距离是 MTRANS_X = 500，MTRANS_Y = 800，那是因为执行 Translate 之前 Matrix 已经具有了一个缩放比例。在右乘的时候影响到了具体的数值计算，可以用矩阵乘法计算一下。</p>

  <p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
0.5 &amp; 0 &amp; 0 \\
0 &amp; 0.8 &amp; 0 \\
0 &amp; 0 &amp; 1
\end{1} 
\right ]  
\cdot 
\left [ 
\begin{matrix} 
1 &amp; 0 &amp; 1000 \\
0 &amp; 1 &amp; 1000 \\
0 &amp; 0 &amp; 1
\end{1} 
\right ] 
= 
\left [ 
\begin{matrix} 
0.5*1+0*0+0*0 &amp; 0.5*0+0*1+0*0 &amp; 0.5*1000+0*1000+0*1\\
0*1+0.8*0+0*0 &amp; 0*0+0.8*1+0*1 &amp; 0*1000+0.8*1000+0*1\\
0*1+0*0+1*0   &amp; 0*0+0*1+1*0   &amp; 0*1000+0*1000+1*1
\end{1} 
\right ]
$$" alt="" /></p>

  <p>最终结果为：</p>

  <p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
0.5 &amp; 0   &amp; 500\\
0   &amp; 0.8 &amp; 800\\
0   &amp; 0   &amp; 1
\end{1} 
\right ]
$$" alt="" /></p>

  <p>当 T*S 的时候，缩放比例则不会影响到 MTRANS_X 和 MTRANS_Y ，具体可以使用矩阵乘法自己计算一遍。</p>
</blockquote>

<h2 id="如何理解和使用-pre-和-post-">如何理解和使用 pre 和 post ？</h2>

<p>不要去管什么先后论，顺序论，就按照最基本的矩阵乘法理解。</p>

<div class="highlighter-rouge"><pre class="highlight"><code>pre  : 右乘， M‘ = M*A
post : 左乘， M’ = A*M
</code></pre>
</div>

<p><strong>那么如何使用？</strong></p>

<p>正确使用方式就是先构造正常的 Matrix 乘法顺序，之后根据情况使用 pre 和 post 来把这个顺序实现。</p>

<p>还是用一个最简单的例子理解，假设需要围绕某一点旋转。</p>

<p>可以用这个方法 <code class="highlighter-rouge">xxxRotate(angle, pivotX, pivotY)</code> ,由于我们这里需要组合构造一个 Matrix，所以不直接使用这个方法。</p>

<p>首先，有两条基本定理：</p>

<ul>
  <li>
    <p>所有的操作(旋转、平移、缩放、错切)默认都是以坐标原点为基准点的。</p>
  </li>
  <li>
    <p>之前操作的坐标系状态会保留，并且影响到后续状态。</p>
  </li>
</ul>

<p>基于这两条基本定理，我们可以推算出要基于某一个点进行旋转需要如下步骤：</p>

<div class="highlighter-rouge"><pre class="highlight"><code>1. 先将坐标系原点移动到指定位置，使用平移 T
2. 对坐标系进行旋转，使用旋转 S (围绕原点旋转)
3. 再将坐标系平移回原来位置，使用平移 -T
</code></pre>
</div>

<p>具体公式如下：</p>

<blockquote>
  <p>M 为原始矩阵，是一个单位矩阵， M‘ 为结果矩阵， T 为平移， R为旋转</p>
</blockquote>

<div class="highlighter-rouge"><pre class="highlight"><code>M' = M*T*R*-T = T*R*-T
</code></pre>
</div>

<p>按照公式写出来的伪代码如下：</p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preRotate</span><span class="o">(</span><span class="n">angle</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(-</span><span class="n">pivotX</span><span class="o">,</span> <span class="o">-</span><span class="n">pivotY</span><span class="o">);</span>
</code></pre>
</div>

<p>围绕某一点操作可以拓展为通用情况，即：</p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">);</span>
<span class="c1">// 各种操作，旋转，缩放，错切等，可以执行多次。</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(-</span><span class="n">pivotX</span><span class="o">,</span> <span class="o">-</span><span class="n">pivotY</span><span class="o">);</span>
</code></pre>
</div>

<p>公式为：</p>

<div class="highlighter-rouge"><pre class="highlight"><code>M' = M*T* ... *-T = T* ... *-T
</code></pre>
</div>

<p>但是这种方式，两个调整中心的平移函数就拉的太开了，所以通常采用这种写法：</p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="n">Matrix</span> <span class="n">matrix</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="c1">// 各种操作，旋转，缩放，错切等，可以执行多次。</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">pivotX</span><span class="o">,</span><span class="n">pivotY</span><span class="o">);</span>
<span class="n">matrix</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(-</span><span class="n">pivotX</span><span class="o">,</span> <span class="o">-</span><span class="n">pivotY</span><span class="o">);</span>
</code></pre>
</div>

<p>这样公式为：</p>

<div class="highlighter-rouge"><pre class="highlight"><code>M' = T*M* ... *-T = T* ... *-T
</code></pre>
</div>

<p>可以看到最终化简结果是相同的。</p>

<p>所以说，pre 和 post 就是用来调整乘法顺序的，正常情况下应当正向进行构建出乘法顺序公式，之后根据实际情况调整书写即可。</p>

<p><strong>在构造 Matrix 时，个人建议尽量使用一种乘法，前乘或者后乘，这样操作顺序容易确定，出现问题也比较容易排查。当然，由于矩阵乘法不满足交换律，前乘和后乘的结果是不同的，使用时应结合具体情景分析使用。</strong></p>

<h3 id="下面我们用不同对方式来构造一个相同的矩阵">下面我们用不同对方式来构造一个相同的矩阵:</h3>

<p>注意:</p>

<ul>
  <li>1.由于矩阵乘法不满足交换律，请保证使用初始矩阵(Initial Matrix)，否则可能导致运算结果不同。</li>
  <li>2.注意构造顺序，顺序是会影响结果的。</li>
  <li>3.Initial Matrix是指new出来的新矩阵，或者reset后的矩阵，是一个单位矩阵。</li>
</ul>

<h4 id="1仅用pre">1.仅用pre：</h4>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">// 使用pre， M' = M*T*S = T*S</span>
<span class="n">Matrix</span> <span class="n">m</span> <span class="err">＝</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">reset</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">preTranslate</span><span class="o">(</span><span class="n">tx</span><span class="o">,</span> <span class="n">ty</span><span class="o">);</span> 
<span class="n">m</span><span class="o">.</span><span class="na">preScale</span><span class="o">(</span><span class="n">sx</span><span class="o">,</span> <span class="n">sy</span><span class="o">);</span>
</code></pre>
</div>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Result Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
 = 
 \left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Initial Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
\cdot 
\left [ 
\begin{matrix} 
1 &amp; 0 &amp; \Delta x \\
0 &amp; 1 &amp; \Delta y \\
0 &amp; 0 &amp; 1
\end{1} 
\right ] 
\cdot 
\left [ 
\begin{matrix} 
sx &amp; 0 &amp; 0\\
0 &amp; sy &amp; 0\\
0 &amp; 0 &amp; 1
\end{1} 
\right ]
$$" alt="" /></p>

<h4 id="2仅用post">2.仅用post:</h4>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">// 使用post， M‘ = T*S*M = T*S</span>
<span class="n">Matrix</span> <span class="n">m</span> <span class="err">＝</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">reset</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">postScale</span><span class="o">(</span><span class="n">sx</span><span class="o">,</span> <span class="n">sy</span><span class="o">);</span>  <span class="c1">//，越靠前越先执行。</span>
<span class="n">m</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">tx</span><span class="o">,</span> <span class="n">ty</span><span class="o">);</span>
</code></pre>
</div>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Result Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix} 
1 &amp; 0 &amp; \Delta x \\
0 &amp; 1 &amp; \Delta y \\
0 &amp; 0 &amp; 1
\end{1} 
\right ] 
\cdot 
\left [ 
\begin{matrix} 
sx &amp; 0 &amp; 0\\
0 &amp; sy &amp; 0\\
0 &amp; 0 &amp; 1
\end{1} 
\right ]
\cdot 
 \left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Initial Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
$$" alt="" /></p>

<h4 id="3混合">3.混合:</h4>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">// 混合 M‘ = T*M*S = T*S</span>
<span class="n">Matrix</span> <span class="n">m</span> <span class="err">＝</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">reset</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">preScale</span><span class="o">(</span><span class="n">sx</span><span class="o">,</span> <span class="n">sy</span><span class="o">);</span>  
<span class="n">m</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">tx</span><span class="o">,</span> <span class="n">ty</span><span class="o">);</span>
</code></pre>
</div>

<p>或:</p>

<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">// 混合 M‘ = T*M*S = T*S</span>
<span class="n">Matrix</span> <span class="n">m</span> <span class="err">＝</span> <span class="k">new</span> <span class="n">Matrix</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">reset</span><span class="o">();</span>
<span class="n">m</span><span class="o">.</span><span class="na">postTranslate</span><span class="o">(</span><span class="n">tx</span><span class="o">,</span> <span class="n">ty</span><span class="o">);</span>
<span class="n">m</span><span class="o">.</span><span class="na">preScale</span><span class="o">(</span><span class="n">sx</span><span class="o">,</span> <span class="n">sy</span><span class="o">);</span>  
</code></pre>
</div>

<blockquote>
  <p>由于此处只有两步操作，且指定了先后，所以代码上交换并不会影响结果。</p>
</blockquote>

<p>用矩阵表示:</p>

<p><img src="http://latex.codecogs.com/png.latex?$$
\left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Result Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
 = 
\left [ 
\begin{matrix} 
1 &amp; 0 &amp; \Delta x \\
0 &amp; 1 &amp; \Delta y \\
0 &amp; 0 &amp; 1
\end{1} 
\right ] 
\cdot 
 \left [ 
\begin{matrix} 
 &amp; &amp;\\
 &amp; Initial Matrix &amp;\\
 &amp; &amp;
\end{1} 
\right ] 
\cdot 
\left [ 
\begin{matrix} 
sx &amp; 0 &amp; 0\\
0 &amp; sy &amp; 0\\
0 &amp; 0 &amp; 1
\end{1} 
\right ]
$$" alt="" /></p>

<p><strong>注意: 由于矩阵乘法不满足交换律，请保证初始矩阵为单位矩阵，如果初始矩阵不为单位矩阵，则导致运算结果不同。</strong></p>

<p>上面虽然用了很多不同的写法，但最终的化简公式是一样的，这些不同的写法，都是根据同一个公式反向推算出来的。</p>

<h2 id="matrix方法表">Matrix方法表</h2>

<p>这个方法表，暂时放到这里让大家看看，方法的使用讲解放在下一篇文章中。</p>

<table>
  <thead>
    <tr>
      <th>方法类别</th>
      <th>相关API</th>
      <th>摘要</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>基本方法</td>
      <td>equals hashCode toString toShortString</td>
      <td>比较、 获取哈希值、 转换为字符串</td>
    </tr>
    <tr>
      <td>数值操作</td>
      <td>set reset setValues getValues</td>
      <td>设置、 重置、 设置数值、 获取数值</td>
    </tr>
    <tr>
      <td>数值计算</td>
      <td>mapPoints mapRadius mapRect mapVectors</td>
      <td>计算变换后的数值</td>
    </tr>
    <tr>
      <td>设置(set)</td>
      <td>setConcat setRotate setScale setSkew setTranslate</td>
      <td>设置变换</td>
    </tr>
    <tr>
      <td>前乘(pre)</td>
      <td>preConcat preRotate preScale preSkew preTranslate</td>
      <td>前乘变换</td>
    </tr>
    <tr>
      <td>后乘(post)</td>
      <td>postConcat postRotate postScale postSkew postTranslate</td>
      <td>后乘变换</td>
    </tr>
    <tr>
      <td>特殊方法</td>
      <td>setPolyToPoly setRectToRect rectStaysRect setSinCos</td>
      <td>一些特殊操作</td>
    </tr>
    <tr>
      <td>矩阵相关</td>
      <td>invert isAffine isIdentity</td>
      <td>求逆矩阵、 是否为仿射矩阵、 是否为单位矩阵 …</td>
    </tr>
  </tbody>
</table>

<h2 id="总结">总结</h2>

<p>对于Matrix重在理解，理解了其中的原理之后用起来将会更加得心应手。</p>

<p>学完了本篇之后，推荐配合鸿洋大大的视频课程 <a href="http://www.imooc.com/learn/239">
打造个性的图片预览与多点触控</a> 食用，定然能够让你对Matrix对理解更上一层楼。</p>

<p>由于个人水平有限，文章中可能会出现错误，如果你觉得哪一部分有错误，或者发现了错别字等内容，欢迎在评论区告诉我，另外，据说关注 <a href="http://weibo.com/GcsSloop">作者微博</a> 不仅能第一时间收到新文章消息，还能变帅哦。</p>

<h2 id="about">About</h2>

<p><a href="http://www.gcssloop.com/customview/CustomViewIndex">本系列相关文章</a></p>

<p>作者微博: <a href="http://weibo.com/GcsSloop">GcsSloop</a></p>

<h2 id="参考资料">参考资料</h2>

<p><a href="https://developer.android.com/reference/android/graphics/Matrix.html">Matrix</a><br />
<a href="http://biandroid.iteye.com/blog/1399462">Android中图像变换Matrix的原理、代码验证和应用</a><br />
<a href="http://blog.csdn.net/linmiansheng/article/details/18820599">Android中关于矩阵（Matrix）前乘后乘的一些认识</a><br />
<a href="https://zh.wikipedia.org/wiki/%E4%BB%BF%E5%B0%84%E5%8F%98%E6%8D%A2">维基百科-仿射变换</a><br />
<a href="https://zh.wikipedia.org/wiki/%E9%BD%90%E6%AC%A1%E5%9D%90%E6%A0%87">维基百科-齐次坐标</a><br />
<a href="https://zh.wikipedia.org/wiki/%E7%BA%BF%E6%80%A7%E6%98%A0%E5%B0%84">维基百科-线性映射</a><br />
<a href="https://oncemore2020.github.io/blog/homogeneous/">齐次坐标系入门级思考</a><br />
<a href="https://guangchun.wordpress.com/2011/10/12/affineandhomogeneous/">仿射变换与齐次坐标</a><br /></p>

    <hr>
  </section>
</article>

<!--广告-->

<!--
<div>
<a href="https://m.aliyun.com/act/team1111/?spm=5176.11533457.1089570.5.424777e3AF8WOJ&userCode=hn5smxtw#/" target="_blank"><img src="/assets/aliyun/1111-980-120.jpg" width="100%"></a>
</div>
-->
<!--捐赠晶石-->
<section class="contribute">
    <script type="text/javascript"> 
      function toggle() {
        var con = document.getElementById("contribute");
        if (con.style.display == "none") {
          con.style.display = "block";
        } else {
          con.style.display = "none";
        }
      }
    </script> 
    <blockquote style="background-color:#F5F5F5; padding: 10px 20px 20px 10px; margin:0px" >
      <h4> 如果你觉得我的文章对你有帮助的话，欢迎赞助一些服务器费用! </h4>
      <p></p>
      <a id=“btn-toggle-contribute” class="btn-contribute" onclick="toggle()" >¥ 点击赞助</a>
      <br>
      <div id="contribute" style="display:none;">
        <p align="center" >
        <img src="/assets/images/wechat.png" alt="微信">
        <img src="/assets/images/alipay.png" alt="支付宝">
        </p>
        <p align="left" >
          <b>感谢所有支持我的魔法师，所有支持过我的魔法师都可以通过微信(GcsSloop)联系我，获赠我的付费专栏！</b>
          <!--
          <a href="/contribute">点击这里查看捐赠者名单。</a>
          -->
        </p>
      </div>
    </blockquote>
</section>
<div>
  <h2>欢迎关注我的微信公众号</h2>
  <img src="/assets/images/banner.jpg" width="100%">
</div>

<!--阅读更多-->
<section class="read-more">
  
  
  <div class="read-more-item">
    <span class="read-more-item-dim">最近的文章</span>
    <h2 class="post-list__post-title post-title"><a href="/tips/arratlist-linkedlist-performance" title="link to ArrayList与LinkedList遍历性能比较">ArrayList与LinkedList遍历性能比较</a></h2>
    <p class="excerpt">用实例测试ArrayList与LinkedList遍历性能。结构差别:我们常用的List有两种，ArrayList和LinkedList，虽然两者都是LIst，但由于内部存储结构的不同，使用不同...&hellip;</p>
    <div class="post-list__meta">
      <time datetime="2016-08-21 00:00:00 +0800" class="post-list__meta--date date">2016-08-21</time> &#8226; <span class="post-list__meta--tags tags">Tips</span>
      <br/><br/>
      <a style="float:none; margin:0 auto;" class="btn-border-small" href=/tips/arratlist-linkedlist-performance>继续阅读</a></div>
   </div>
   
   
   
   
   <div class="read-more-item">
       <span class="read-more-item-dim">更早的文章</span>
       <h2 class="post-list__post-title post-title"><a href="/customview/Path_PathMeasure" title="link to 安卓自定义View进阶-PathMeasure">安卓自定义View进阶-PathMeasure</a></h2>
       <p class="excerpt">可以看到，在经过 Path之基本操作Path之贝塞尔曲线 和 Path之完结篇 后， Path中各类方法基本上都讲完了，表格中还没有讲解到到方法就是矩阵变换了，难道本篇终于要讲矩阵了？非也，矩阵...&hellip;</p>
       <div class="post-list__meta">
          <time datetime="2016-06-02 00:00:00 +0800" class="post-list__meta--date date">2016-06-02</time> &#8226; <span class="post-list__meta--tags tags">CustomView</span>
          <br/><br/>
          <a style="float:none; margin:0 auto;" class="btn-border-small" href=/customview/Path_PathMeasure>继续阅读</a>
       </div>
   </div>
   
</section>

<!--网易云跟帖-->
<!--
<div id="cloud-tie-wrapper" class="cloud-tie-wrapper"></div>
<script src="https://img1.cache.netease.com/f2e/tie/yun/sdk/loader.js"></script>
<script>
var cloudTieConfig = {
  url: document.location.href, 
  sourceId: "",
  productKey: "a85dba2840134721a7b69a15b2e0f217",
  target: "cloud-tie-wrapper"
};
var yunManualLoad = true;
Tie.loader("aHR0cHM6Ly9hcGkuZ2VudGllLjE2My5jb20vcGMvbGl2ZXNjcmlwdC5odG1s", true);
</script>
-->

<style type="text/css">
.isso-comment > div.avatar {
    border: 0px;
    box-shadow: none;
    display: block;
    float: left;
    width: 7%;
    margin: 3px 15px 0 0;
}
.isso-postbox > .form-wrapper > .auth-section .post-action > input {
    border-radius: 6px;
    padding: 6px;
    padding-left: 16px;
    padding-right: 16px;
    border: 1px solid #CCC;
    background-color: #D58D44;
    cursor: pointer;
    outline: 0;
    color: #fff;
    size: 10;
    line-height: 1.4em;
    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
}
.isso-postbox > .form-wrapper > .auth-section .post-action > input:hover {
    background-color: #272822;
}
.isso-postbox > .form-wrapper > .auth-section .post-action > input:active {
    background-color: #986530;
}
</style>

<section id="isso-thread"></section>

<script data-isso="//47.52.58.34:1234/"
        data-isso-css="true"
        data-isso-lang="zh"
        data-isso-reply-to-self="false"
        data-isso-require-author="false"
        data-isso-require-email="false"
        data-isso-max-comments-top="10"
        data-isso-max-comments-nested="5"
        data-isso-reveal-on-click="5"
        data-isso-avatar="true"
        data-isso-avatar-bg="#f0f0f0"
        data-isso-avatar-fg="#9abf88 #5698c4 #e279a3 #9163b6 ..."
        data-isso-vote="true"
        data-vote-levels=""
        src="//47.52.58.34:1234/js/embed.min.js">
        </script>

<!--
<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
-->
<!-- OneV's Den -->
<!--
<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-3324997515191619"
     data-ad-slot="9170309685"
     data-ad-format="auto"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>
-->

            <section class="footer">
    <footer>
    	<span class="footer__copyright">本站点采用<a rel="license" href="https://creativecommons.org/licenses/by-nc-nd/4.0/deed.zh" target="_blank">知识共享 署名-非商业性使用-禁止演绎 4.0 国际 许可协议</a></span>
        <span class="footer__copyright">本站由 <a href="http://www.GcsSloop.com">@GcsSloop</a> 创建，采用 <a href="https://github.com/GcsSloop/Gcs-Vno-Jekyll" target="_blank">Gcs-Vno-Jekyll</a> 作为主题。<span id="busuanzi_container_site_pv"> 总访问量 <span id="busuanzi_value_site_pv"></span> 次</span> - &copy; 2019</span>
        <span class="footer__sitemap, footer__copyright"><a href="http://www.gcssloop.com/sitemap.xml" target="_blank">Site Map</a>
        <a href="http://www.gcssloop.com/vip" target="_blank">vip</a></span>
    </footer>
</section>

        </div>
    </div>
    
    <script type="text/javascript" src="//code.jquery.com/jquery-1.11.3.min.js"></script>

<script type="text/javascript" src="/js/highlight.pack.js"></script>
<script>hljs.initHighlightingOnLoad();</script>

<script type="text/javascript" src="/js/main.js"></script>

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-82493667-1', 'auto');
  ga('send', 'pageview');

</script>

    
  </body>

</html>
